.TH std::multiset::operator= 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::multiset::operator= \- std::multiset::operator=

.SH Synopsis
   multiset& operator=( const multiset& other );                  \fB(1)\fP
   multiset& operator=( multiset&& other );                               \fI(since C++11)\fP
                                                                          \fI(until C++17)\fP
   multiset& operator=( multiset&& other ) noexcept(/* see below  \fB(2)\fP     \fI(since C++17)\fP
   */);
   multiset& operator=( std::initializer_list<value_type> ilist       \fB(3)\fP \fI(since C++11)\fP
   );

   Replaces the contents of the container.

   1) Copy assignment operator. Replaces the contents with a copy of the contents of
   other.

If
std::allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value
is true, the allocator of *this is replaced by a copy of other. If the allocator of
*this after assignment would compare unequal to its old value, the old allocator is  (since
used to deallocate the memory, then the new allocator is used to allocate it before  C++11)
copying the elements. Otherwise, the memory owned by *this may be reused when
possible. In any case, the elements originally belonging to *this may be either
destroyed or replaced by element-wise copy-assignment.

   2) Move assignment operator. Replaces the contents with those of other using move
   semantics (i.e. the data in other is moved from other into this container). other is
   in a valid but unspecified state afterwards.
   If
   std::allocator_traits<allocator_type>::propagate_on_container_move_assignment::value
   is true, the allocator of *this is replaced by a copy of that of other. If it is
   false and the allocators of *this and other do not compare equal, *this cannot take
   ownership of the memory owned by other and must move-assign each element
   individually, allocating additional memory using its own allocator as needed. In any
   case, all elements originally belonging to *this are either destroyed or replaced by
   element-wise move-assignment.
   3) Replaces the contents with those identified by initializer list ilist.

.SH Parameters

   other - another container to use as data source
   ilist - initializer list to use as data source

.SH Return value

   *this

.SH Complexity

   1) Linear in the size of *this and other.
   2) Linear in the size of *this unless the allocators do not compare equal and do not
   propagate, in which case linear in the size of *this and other.
   3) O(NlogN) in general, where N is size() + ilist.size(). Linear if ilist is sorted
   with respect to value_comp().

.SH Exceptions

   1-3) May throw implementation-defined exceptions.                 \fI(until C++17)\fP
   1,3) May throw implementation-defined exceptions.
   2)
   noexcept specification:                                           \fI(since C++17)\fP
   noexcept(std::allocator_traits<Allocator>::is_always_equal::value
   && std::is_nothrow_move_assignable<Compare>::value)

.SH Notes

   After container move assignment (overload \fB(2)\fP), unless element-wise move assignment
   is forced by incompatible allocators, references, pointers, and iterators (other
   than the end iterator) to other remain valid, but refer to elements that are now in
   *this. The current standard makes this guarantee via the blanket statement in
   [container.reqmts]/67, and a more direct guarantee is under consideration via LWG
   issue 2321.

.SH Example

   The following code uses operator= to assign one std::multiset to another:


// Run this code

 #include <initializer_list>
 #include <iostream>
 #include <iterator>
 #include <set>

 void print(auto const comment, auto const& container)
 {
     auto size = std::size(container);
     std::cout << comment << "{ ";
     for (auto const& element : container)
         std::cout << element << (--size ? ", " : " ");
     std::cout << "}\\n";
 }

 int main()
 {
     std::multiset<int> x{1, 2, 3}, y, z;
     const auto w = {4, 5, 6, 7};

     std::cout << "Initially:\\n";
     print("x = ", x);
     print("y = ", y);
     print("z = ", z);

     std::cout << "Copy assignment copies data from x to y:\\n";
     y = x;
     print("x = ", x);
     print("y = ", y);

     std::cout << "Move assignment moves data from x to z, modifying both x and z:\\n";
     z = std::move(x);
     print("x = ", x);
     print("z = ", z);

     std::cout << "Assignment of initializer_list w to z:\\n";
     z = w;
     print("w = ", w);
     print("z = ", z);
 }

.SH Output:

 Initially:
 x = { 1, 2, 3 }
 y = { }
 z = { }
 Copy assignment copies data from x to y:
 x = { 1, 2, 3 }
 y = { 1, 2, 3 }
 Move assignment moves data from x to z, modifying both x and z:
 x = { }
 z = { 1, 2, 3 }
 Assignment of initializer_list w to z:
 w = { 4, 5, 6, 7 }
 z = { 4, 5, 6, 7 }

.SH See also

   constructor   constructs the multiset
                 \fI(public member function)\fP

.SH Category:
     * conditionally noexcept
